Applying UML and Patterns 3/e (Hardcover)

購買商店

Applying UML and Patterns 3/e

$3,150.00

馬上購買

內容描述

Description:

Craig Larman again delivers a clear path for
students to learn object-oriented analysis and design through his clear and
precise writing style.  Larman teaches newcomers to OOA/D learn how to
“think in objects” by presenting three iterations of a single, cohesive case
study, incrementally introducing the requirements and OOA/D activities,
principles, and patterns that are most critical to success.
 
Table of
Contents:

Foreword.
Preface.
I. INTRODUCTION.

1. Object-Oriented Analysis and Design.
       What Will You Learn? Is it
   Useful?
       The Most Important Learning
   Goal?
       What is Analysis and Design?
       What is Object-Oriented Analysis and
   Design?
       A Short Example.
       What is the UML?
       Visual Modeling is a Good
   Thing.
       History.
       Recommended Resources.
2. Iterative, Evolutionary, and Agile.
       What is the UP? Are Other Methods
   Complementary?
       What is Iterative and Evolutionary
   Development?
       What About the Waterfall
   Lifecycle?
       How to do Iterative and Evolutionary
   Analysis and Design?
       What is Risk-Driven and Client-Driven
   Iterative Planning?
       What are Agile Methods and
   Attitudes?
       What is Agile Modeling?
       What is an Agile UP?
       Are There Other Critical UP
   Practices?
       What are the UP Phases?
       What are the UP Disciplines?
       How to Customize the Process? The UP
   Development Case.
       You Know You Didn't Understand
   Iterative Development or the UP When.
       History.
       Recommended Resources.
3. Case Studies.
       What is and isn't Covered in the Case
   Studies?
       Case Study Strategy: Iterative
   Development + Iterative Learning.
       Case One: The NextGen POS
   System.
       Case Two: The Monopoly Game
   System.
   II. INCEPTION.
4. Inception is Not the Requirements Phase.
       What is Inception?
       How Long is Inception?
       What Artifacts May Start in
   Inception?
       You Know You Didn't Understand
   Inception When...
       How Much UML During
   Inception?
5. Evolutionary Requirements.
       Definition: Requirements.
       Evolutionary vs. Waterfall
   Requirements.
       What are Skillful Means to Find
   Requirements?
       What are the Types and Categories of
   Requirements?
       How are Requirements Organized in UP
   Artifacts?
       Does the Book Contain Examples of These
   Artifacts?
       Recommended Resources.
6. Use Cases.
       Example.
       Definition: What are Actors, Scenarios,
   and Use Cases?
       Use Cases and the Use-Case
   Model.
       Motivation: Why Use Cases?
       Definition: Are Use Cases Functional
   Requirements?
       Definition: What are Three Kinds of
   Actors?
       Notation: What are Three Common Use
   Case Formats?
       Example: Process Sale, Fully Dressed
   Style.
       What do the Sections Mean?
       Notation: Are There Other Formats? A
   Two-Column Variation.
       Guideline: Write in an Essential
   UI-Free Style.
       Guideline: Write Terse Use
   Cases.
       Guideline: Write Black-Box Use
   Cases.
       Guideline: Take an Actor and Actor-Goal
   Perspective.
       Guideline: How to Find Use
   Cases.
       Guideline: What Tests Can Help Find
   Useful Use Cases?
       Applying UML: Use Case
   Diagrams.
       Applying UML: Activity
   Diagrams.
       Motivation: Other Benefits of Use
   Cases? Requirements in Context.
       Example: Monopoly Game.
       Process: How to Work With Use Cases in
   Iterative Methods?
       History.
       Recommended Resources.
7. Other Requirements.
       How Complete are these
   Examples?
       Guideline: Should We Analyze These
   Thoroughly During Inception?
       Guideline: Should These Artifacts be at
   the Project Website?
       NextGen Example: (Partial)
   Supplementary Specification.
       Commentary: Supplementary
   Specification.
       NextGen Example: (Partial)
   Vision.
       Commentary: Vision.
       NextGen Example: A (Partial)
   Glossary.
       Commentary: Glossary (Data
   Dictionary).
       NextGen Example: Business Rules (Domain
   Rules).
       Commentary: Domain Rules.
       Process: Evolutionary Requirements in
   Iterative Methods.
       Recommended Resources.
   III. ELABORATION ITERATION 1-BASICS.
8. Iteration 1-Basics.
       Iteration 1 Requirements and Emphasis:
   Core OOA/D Skills.
       Process: Inception and
   Elaboration.
       Process: Planning the Next
   Iteration.
9. Domain Models.
       Example.
       What is a Domain Model?
       Motivation: Why Create a Domain
   Model?
       Guideline: How to Create a Domain
   Model?
       Guideline: How to Find Conceptual
   Classes?
       Example: Find and Draw Conceptual
   Classes.
       Guideline: Agile Modeling-Sketching a
   Class Diagram.
       Guideline: Agile Modeling-Maintain the
   Model in a Tool?
       Guideline: Report Objects-Include
   'Receipt' in the Model?
       Guideline: Think Like a Mapmaker; Use
   Domain Terms.
       Guideline: How to Model the Unreal
   World?
       Guideline: A Common Mistake with
   Attributes vs. Classes.
       Guideline: When to Model with
   'Description' Classes?
       Associations.
       Example: Associations in the Domain
   Models.
       Attributes.
       Example: Attributes in the Domain
   Models.
       Conclusion: Is the Domain Model
   Correct?
       Process: Iterative and Evolutionary
   Domain Modeling.
       Recommended Resources.
10. System Sequence Diagrams.
        Example: NextGen SSD.
        What are System Sequence
    Diagrams?
        Motivation: Why Draw an SSD?
        Applying UML: Sequence
    Diagrams.
        What is the Relationship Between SSDs
    and Use Cases?
        How to Name System Events and
    Operations?
        How to Model SSDs Involving Other
    External Systems?
        What SSD Information to Place in the
    Glossary?
        Example: Monopoly SSD.
        Process: Iterative and Evolutionary
    SSDs.
        History and Recommended
    Resources.
11. Operation Contracts.
        Example.
        Definition: What are the Sections of a
    Contract?
        Definition: What is a System
    Operation?
        Definition: Postconditions.
        Example: enterItem
    Postconditions.
        Guideline: Should We Update the Domain
    Model?
        Guideline: When Are Contracts
    Useful?
        Guideline: How to Create and Write
    Contracts.
        Example: NextGen POS
    Contracts.
        Example: Monopoly Contracts.
        Applying UML: Operations, Contracts,
    and the OCL.
        Process: Operation Contracts Within the
    UP.
        History.
        Recommended Resources.
12. Requirements to Design-Iteratively.
        Iteratively Do the Right Thing, Do the
    Thing Right.
        Provoking Early Change.
        Didn't All That Analysis and Modeling
    Take Weeks To Do?
13. Logical Architecture and UML Package
    Diagrams.
        Example.
        What is the Logical Architecture? And
    Layers?
        What Layers are the Focus in the Case
    Studies?
        What is Software
    Architecture?
        Applying UML: Package
    Diagrams.
        Guideline: Design with
    Layers.
        Guideline: The Model-View Separation
    Principle.
        What's the Connection Between SSDs,
    System Operations, and Layers?
        Example: NextGen Logical Architecture
    and Package Diagram.
        Example: Monopoly Logical
    Architecture?
        Recommended Resources.
14. On to Object Design.
        Agile Modeling and Lightweight UML
    Drawing.
        UML CASE Tools.
        How Much Time Spent Drawing UML Before
    Coding?
        Designing Objects: What are Static and
    Dynamic Modeling?
        The Importance of Object Design Skill
    over UML Notation Skill.
        Other Object Design Techniques: CRC
    Cards.
15. UML Interaction Diagrams.
        Sequence and Communication
    Diagrams.
        Novice UML Modelers Don't Pay Enough
    Attention to Interaction Diagrams!
        Common UML Interaction Diagram
    Notation.
        Basic Sequence Diagram
    Notation.
        Basic Communication Diagram
    Notation.
16. UML Class Diagrams.
        Applying UML: Common Class Diagram
    Notation.
        Definition: Design Class
    Diagram.
        Definition: Classifier.
        Ways to Show UML Attributes: Attribute
    Text and Association Lines.
        Note Symbols: Notes, Comments,
    Constraints, and Method Bodies.
        Operations and Methods.
        Keywords.
        Stereotypes, Profiles, and
    Tags.
        UML Properties and Property
    Strings.
        Generalization, Abstract Classes,
    Abstract Operations.
        Dependency.
        Interfaces.
        Composition Over
    Aggregation.
        Constraints.
        Qualified Association.
        Association Class.
        Singleton Classes.
        Template Classes and
    Interfaces.
        User-Defined Compartments.
        Active Class.
        What's the Relationship Between
    Interaction and Class Diagrams?
17. GRASP: Designing Objects with
    Responsibilities.
        UML versus Design
    Principles.
        Object Design: Example Inputs,
    Activities, and Outputs.
        Responsibilities and
    Responsibility-Driven Design.
        GRASP: A Methodical Approach to Basic
    OO Design.
        What's the Connection Between
    Responsibilities, GRASP, and UML Diagrams?
        What are Patterns?
        Where are We Now?
        A Short Example of Object Design with
    GRASP.
        Applying GRASP to Object
    Design.
        Creator.
        Information Expert (or
    Expert).
        Low Coupling.
        Controller.
        High Cohesion.
        Recommended Resources.
18. Object Design Examples with GRASP.
        What is a Use Case
    Realization?
        Artifact Comments.
        What's Next?
        Use Case Realizations for the NextGen
    Iteration.
        Use Case Realizations for the Monopoly
    Iteration.
        Process: Iterative and Evolutionary
    Object Design.
        Summary.
19. Designing for Visibility.
        Visibility Between Objects.
        What is Visibility?
20. Mapping Designs to Code.
        Programming and Iterative, Evolutionary
    Development.
        Mapping Designs to Code.
        Creating Class Definitions from
    DCDs.
        Creating Methods from Interaction
    Diagrams.
        Collection Classes in Code.
        Exceptions and Error
    Handling.
        Defining the Sale.makeLineItem
    Method.
        Order of Implementation.
        Test-Driven or Test-First
    Development.
        Summary of Mapping Designs to
    Code.
        Introduction to the NextGen POS Program
    Solution.
        Introduction to the Monopoly Program
    Solution.
21. Test-Driven Development and
    Refactoring.
        Test-Driven Development.
        Refactoring.
        Recommended Resources.
    IV. ELABORATION ITERATION 2-MORE PATTERNS.
22. UML Tools and UML as Blueprint.
        Forward, Reverse, and Round-Trip
    Engineering.
        What is a Common Report of Valuable
    Features?
        What to Look For in a Tool?
        If Sketching UML, How to Update the
    Diagrams After Coding?
        Recommended Resources.
23. Quick Analysis Update.
        Case Study: NextGen POS.
        Case Study: Monopoly.
24. Iteration 2-More Patterns.
        From Iteration 1 to 2.
        Iteration-2 Requirements and Emphasis:
    Object Design and Patterns.
25. GRASP: More Objects with
    Responsibilities.
        Polymorphism.
        Pure Fabrication.
        Indirection.
        Protected Variations.
26. Applying GoF Design Patterns.
        Adapter (GoF).
        Some GRASP Principles as a
    Generalization of Other Patterns.
        "Analysis" Discoveries During Design:
    Domain Model.
        Factory.
        Singleton (GoF).
        Conclusion of the External Services
    with Varying Interfaces Problem.
        Strategy (GoF).
        Composite (GoF) and Other Design
    Principles.
        Facade (GoF).
        Observer/Publish-Subscribe/Delegation
    Event Model (GoF).
        Conclusion.
        Recommended Resources.
    V. ELABORATION ITERATION 3-INTERMEDIATE
    TOPICS.
27. Iteration 3-Intermediate Topics.
        NextGen POS.
        Monopoly.
28. UML Activity Diagrams and Modeling.
        Example.
        How to Apply Activity
    Diagrams?
        More UML Activity Diagram
    Notation.
         Guidelines.
        Example: NextGen Activity
    Diagram.
        Process: Activity Diagrams in the
    UP.
        Background.
29. UML State Machine Diagrams and
    Modeling.
        Example.
        Definitions: Events, States, and
    Transitions.
        How to Apply State Machine
    Diagrams?
        More UML State Machine Diagram
    Notation.
        Example: UI Navigation Modeling with
    State Machines.
        Example: NextGen Use Case State Machine
    Diagram.
        Process: State Machine Diagrams in the
    UP.
        Recommended Resources.
30. Relating Use Cases.
        The include Relationship.
        Terminology: Concrete, Abstract, Base,
    and Addition Use Cases.
        The extend Relationship.
        The generalize Relationship.
        Use Case Diagrams.
31. More SSDs and Contracts.
        NextGen POS.
32. Domain Model Refinement.
        New Concepts for the NextGen Domain
    Model.
        Generalization.
        Defining Conceptual Superclasses and
    Subclasses.
        When to Define a Conceptual
    Subclass?
        When to Define a Conceptual
    Superclass?
        NextGen POS Conceptual Class
    Hierarchies.
         Abstract Conceptual
    Classes.
        Modeling Changing States.
        Class Hierarchies and Inheritance in
    Software.
        Association Classes.
        Aggregation and Composition.
        Time Intervals and Product
    Prices-Fixing an Iteration 1 "Error".
        Association Role Names.
        Roles as Concepts versus Roles in
    Associations.
        Derived Elements.
        Qualified Associations.
        Reflexive Associations.
        Using Packages to Organize the Domain
    Model.
        Example: Monopoly Domain Model
    Refinements.
33. Architectural Analysis.
        Process: When Do We Start Architectural
    Analysis?
        Definition: Variation and Evolution
    Points.
        Architectural Analysis.
        Common Steps in Architectural
    Analysis.
        The Science: Identification and
    Analysis of Architectural Factors.
        Example: Partial NextGen POS
    Architectural Factor Table.
        The Art: Resolution of Architectural
    Factors.
        Summary of Themes in Architectural
    Analysis.
        Process: Iterative Architecture in the
    UP.
        Recommended Resources.
34. Logical Architecture Refinement.
        Example: NextGen Logical
    Architecture.
        Collaborations with the Layers
    Pattern.
        Other Layer Pattern Issues.
        Model-View Separation and "Upward"
    Communication.
        Recommended Resources.
35. More Object Design with GoF Patterns.
        Example: NextGen POS.
        Failover to Local Services; Performance
    with Local Caching.
        Handling Failure.
        Failover to Local Services with a Proxy
    (GoF).
        Designing for Non-Functional or Quality
    Requirements.
        Accessing External Physical Devices
    with Adapters.
        Abstract Factory (GoF) for Families of
    Related Objects.
        Handling Payments with Polymorphism and
    Do It Myself.
        Example: Monopoly.
        Conclusion.
36. Package Design.
        Package Organization
    Guidelines.
        Recommended Resources.
37. UML Deployment and Component Diagrams.
        Deployment Diagrams.
        Component Diagrams.
38. Designing a Persistence Framework with
    Patterns.
        The Problem: Persistent
    Objects.
        The Solution: A Persistence Service
    from a Persistence Framework.
        Frameworks.
        Requirements for the Persistence
    Service and Framework.
        Key Ideas.
        Pattern: Representing Objects as
    Tables.
        UML Data Modeling Profile.
        Pattern: Object Identifier.
        Accessing a Persistence Service with a
    Façade.
        Mapping Objects: Database Mapper or
    Database Broker Pattern.
        Framework Design with the Template
    Method Pattern.
        Materialization with the Template
    Method Pattern.
        Configuring Mappers with a
    MapperFactory.
        Pattern: Cache Management.
        Consolidating and Hiding SQL Statements
    in One Class.
        Transactional States and the State
    Pattern.
        Designing a Transaction with the
    Command Pattern.
        Lazy Materialization with a Virtual
    Proxy.
        How to Represent Relationships in
    Tables.
        PersistentObject Superclass and
    Separation of Concerns.
        Unresolved Issues.
39. Documenting Architecture: UML & the N+1 View
    Model.
        The SAD and Its Architectural
    Views.
        Notation: The Structure of a
    SAD.
        Example: A NextGen POS SAD.
        Example: A Jakarta Struts
    SAD.
        Process: Iterative Architectural
    Documentation.
        Recommended Resources.
    VI. SPECIAL TOPICS
40. More on Iterative Development and Agile Project
    Management.
        How to Plan an Iteration?
        Adaptive versus Predictive
    Planning.
        Phase and Iteration Plans.
        How to Plan Iterations with Use Cases
    and Scenarios?
        The (In)Validity of Early
    Estimates.
        Organizing Project
    Artifacts.
        You Know You Didn't Understand
    Iterative Planning When...
    Recommended Resources.
    Bibliography.
    Glossary.
    Index.